const { MCPDemoClient } = require('../client/index');
const assert = require('assert');
const fs = require('fs').promises;
const path = require('path');
const winston = require('winston');

// 配置测试日志
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ filename: 'logs/test.log' })
  ]
});

class MCPClientTest {
  constructor() {
    this.client = new MCPDemoClient();
    this.testFile = path.join(__dirname, 'test.txt');
  }

  async setup() {
    try {
      await this.client.connect();
      logger.info('测试客户端连接成功');
    } catch (error) {
      logger.error('测试客户端连接失败:', error);
      throw error;
    }
  }

  async cleanup() {
    try {
      // 清理测试文件
      if (await fs.access(this.testFile).then(() => true).catch(() => false)) {
        await fs.unlink(this.testFile);
      }
      logger.info('测试清理完成');
    } catch (error) {
      logger.error('测试清理失败:', error);
    }
  }

  async testTextProcessing() {
    try {
      const text = "Hello, MCP Testing!";
      
      // 测试单词计数
      const wordCount = await this.client.processText(text, 'wordCount');
      assert.strictEqual(wordCount, 3, '单词计数测试失败');
      
      // 测试字符计数
      const charCount = await this.client.processText(text, 'charCount');
      assert.strictEqual(charCount, 17, '字符计数测试失败');
      
      // 测试转大写
      const upperCase = await this.client.processText(text, 'toUpperCase');
      assert.strictEqual(upperCase, "HELLO, MCP TESTING!", '转大写测试失败');
      
      logger.info('文本处理测试通过');
      return true;
    } catch (error) {
      logger.error('文本处理测试失败:', error);
      return false;
    }
  }

  async testCalculations() {
    try {
      const numbers = [1, 2, 3, 4, 5];
      
      // 测试求和
      const sum = await this.client.calculate('sum', numbers);
      assert.strictEqual(sum, 15, '求和测试失败');
      
      // 测试平均值
      const avg = await this.client.calculate('average', numbers);
      assert.strictEqual(avg, 3, '平均值测试失败');
      
      // 测试最大值
      const max = await this.client.calculate('max', numbers);
      assert.strictEqual(max, 5, '最大值测试失败');
      
      // 测试最小值
      const min = await this.client.calculate('min', numbers);
      assert.strictEqual(min, 1, '最小值测试失败');
      
      logger.info('计算功能测试通过');
      return true;
    } catch (error) {
      logger.error('计算功能测试失败:', error);
      return false;
    }
  }

  async testFileOperations() {
    try {
      // 创建测试文件
      const testContent = '这是测试文件内容';
      await fs.writeFile(this.testFile, testContent);
      
      // 测试文件读取
      const result = await this.client.readFile(this.testFile);
      assert.strictEqual(result.content, testContent, '文件读取测试失败');
      
      logger.info('文件操作测试通过');
      return true;
    } catch (error) {
      logger.error('文件操作测试失败:', error);
      return false;
    }
  }

  async runAllTests() {
    try {
      console.log('开始MCP客户端测试...\n');
      
      await this.setup();
      
      console.log('1. 测试文本处理功能');
      const textResult = await this.testTextProcessing();
      console.log(textResult ? '✓ 文本处理测试通过' : '✗ 文本处理测试失败');
      
      console.log('\n2. 测试计算功能');
      const calcResult = await this.testCalculations();
      console.log(calcResult ? '✓ 计算功能测试通过' : '✗ 计算功能测试失败');
      
      console.log('\n3. 测试文件操作');
      const fileResult = await this.testFileOperations();
      console.log(fileResult ? '✓ 文件操作测试通过' : '✗ 文件操作测试失败');
      
      await this.cleanup();
      
      console.log('\n测试完成！');
    } catch (error) {
      console.error('测试过程中发生错误:', error);
    }
  }
}

// 导出测试类
module.exports = MCPClientTest;

// 如果直接运行此文件，则执行测试
if (require.main === module) {
  const test = new MCPClientTest();
  test.runAllTests();
} 